package com.sumainfor.pc.market.service;

import com.alibaba.fastjson.JSONObject;
import com.qiniu.util.Json;
import com.sumainfor.common.Constants;
import com.sumainfor.common.config.RedisUtils;
import com.sumainfor.common.entity.SysUserVo;
import com.sumainfor.common.util.*;
import com.sumainfor.common.utlis.ComUtils;
import com.sumainfor.common.utlis.ListMapMergeUtil;
import com.sumainfor.common.utlis.ParamsCommon;
import com.sumainfor.pc.market.dao.*;
import com.sumainfor.pc.market.feign.TenantFeign;
import com.sumainfor.pc.market.feign.Zfeign.ZpcEpcFeign;
import com.sumainfor.pc.market.feign.ZuulFeign.ZuulFeign;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.io.Serializable;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 工单配置详表
 */
@Service
public class RdWorderInfoService implements Serializable {

    private ReentrantLock lock = new ReentrantLock(false);

    Logger log = LoggerFactory.getLogger(RdWorderInfoService.class);// 日志

    @Autowired
    private RdWorderInfoMapper rdWorderInfoMapper;
    @Autowired
    private RdTenantAskMapper rdTenantAskMapper;
    @Autowired
    private ZpcEpcFeign zpcEpcFeign;
    @Autowired
    UtilsMapper utilsMapper;
    @Autowired
    private RedisUtils redisUtils;
    @Autowired
    ZuulFeign ZuulFeign;

    @Autowired
    TenantFeign TenantFeign;

    String UUID = null;

    /**
     * 确认到达
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult updateWorderInfoIfArrive(Map<String, Object> params) {
        JsonResult result = new JsonResult();
        if (params.get("ProOperaType") == null || params.get("HouConId") == null || params.get("WoInfoId") == null) {
            return result.putFailed("参数不正确");
        }
        // IfLockOrEte  1查询门锁  2查电表
        params.put("IfLockOrEte",1);
        /**
         * 加锁操作
         */
        lock.lock();
        try {
            try {
                //去工程部查询该租客签约房源的智能设备信息
                JsonResult zpcResult = zpcEpcFeign.getHoRdWorder(params);
                SysUserVo userVo = ContextUtils.getSysUser();
                params.put("TenMode",userVo.getMobile());
                System.out.println("工程部查询到的数据:" + zpcResult);
                if (!zpcResult.get("errorCode").toString().equals("0")) {
                    return result.putFailed("服务器繁忙");
                }
                List<Map<String, Object>> inteList = (List<Map<String, Object>>) zpcResult.get("result");
                System.out.println("查询到的数据inteList=" + inteList);
                String nowDate = DateUtils.getNowTime("yyyy-MM-dd");
                //获取今天的时间字符串
                String toDay = nowDate + InteDeviceLockConfig.LOCK_TIME_START;
                //获取明天的时间
                Date date1 = DateUtils.addDateDays(DateUtils.stringToDate(nowDate, "yyyy-MM-dd"), 1);
                //明天的时间转换成时间字符串
                String tomorrow = DateUtils.format(date1, "yyyy-MM-dd") + InteDeviceLockConfig.LOCK_TIME_START;
                System.out.println("今天的时间：" + DateUtils.getNowTime("yyyy-MM-dd") + InteDeviceLockConfig.LOCK_TIME_START);
                System.out.println("明天的时间：" + DateUtils.format(date1, "yyyy-MM-dd") + InteDeviceLockConfig.LOCK_TIME_START);
                for (Map<String, Object> inteMap : inteList) {
                    //智能设备供应商     0.蜂电   1.大华   2.科技侠   3.果加
                    if (inteMap.get("Intelligent") != null) {
//                        InteMap.put("SmaId", UUIDUtils.generateShortUuid());//智能设备密码记录UUID
//                        InteMap.put("SmaType",inteMap.get("Intelligent"));//智能设备供应商     2.科技侠   3.果加
//                        InteMap.put("Identifier",inteMap.get("Identifier"));//智能设备识别码
//                        InteMap.put("CodeType",2);//密码类型   1.键盘密码  2.蓝牙密码
//                        InteMap.put("HouConId",inteMap.get("HouConId"));//房源配置详表编号
//                        InteMap.put("HouConType",inteMap.get("HouConType"));//房源配置类型 1公共区域 2房间 3整租
//                        InteMap.put("OperTime",InteMap.get("instm"));//操作时间
                        if (inteMap.get("Intelligent").toString().equals("2")) {
                            String DeviceLockToken = redisUtils.get("DeviceLockToken");
                            //如果获取不到就重新登录
                            if (DeviceLockToken == null) {
                                Map<String, Object> tokenMap = new HashMap<String, Object>();
                                tokenMap.put("client_id", InteDeviceLockConfig.CLIENT_ID);
                                tokenMap.put("client_secret", InteDeviceLockConfig.CLIENT_SECRET);
                                tokenMap.put("grant_type", InteDeviceLockConfig.GRANT_TYPE_PASSWORD);
                                tokenMap.put("username", InteDeviceLockConfig.USERNAME);
                                tokenMap.put("password", InteDeviceLockConfig.PASSWORD);
                                tokenMap.put("redirect_uri", InteDeviceLockConfig.REDIRECT_URL);
                                System.out.println("请求科技侠的参数:" + tokenMap);
                                tokenMap = InteDeviceLockUtil.oauth2Token(tokenMap);
                                if (tokenMap.get("access_token") != null) {
                                    DeviceLockToken = tokenMap.get("access_token").toString();
                                    //token存到redis中
                                    redisUtils.set("DeviceLockToken", DeviceLockToken, Long.valueOf(tokenMap.get("expires_in").toString()));
                                } else {
                                    return result.putFailed("token获取失败");
                                }
                            }
                            Map<String, Object> deviceLockMap = new HashMap<String, Object>();
                            deviceLockMap.put("clientId", InteDeviceLockConfig.CLIENT_ID);
                            deviceLockMap.put("accessToken", DeviceLockToken);//科技侠访问令牌
                            //智能设备编码
                            deviceLockMap.put("lockId", inteMap.get("Identifier"));
                            //用户
                            deviceLockMap.put("receiverUsername", params.get("TenMode"));
                            //钥匙有效时间
                            deviceLockMap.put("startDate", InteDeviceLockUtil.getTimeSign(toDay,"yyyy-MM-dd HH:mm:ss"));
                            //钥匙失效时间
                            deviceLockMap.put("endDate", InteDeviceLockUtil.getTimeSign(tomorrow,"yyyy-MM-dd HH:mm:ss"));
                            //当前时间
                            deviceLockMap.put("date", InteDeviceLockUtil.getTimeSign());
                            //1 发送钥匙时候如果发现用户没有注册过科技侠就自动创建用户
                            deviceLockMap.put("createUser", "1");
                            System.out.println("deviceLockMap：" + deviceLockMap);

                            Map<String, Object> mapResult = InteDeviceLockUtil.keySend(deviceLockMap);
                            System.out.println("钥匙返回的参数:" + mapResult);

                            if (mapResult.get("errcode") != null && mapResult.get("errcode").toString().equals("0")) {
//                                InteMap.put("CodeId",mapResult.get("keyId"));//密码ID
//                                InteMap.put("Operator",ContextUtils.getUserId());
                            } else {
                                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                                return result.putFailed(mapResult.get("errmsg").toString());
                            }
                        } else if (inteMap.get("Intelligent").toString().equals("3")) {//果加门锁
                            String GuoJiaToken = redisUtils.get("GuoJiaToken");
                            //如果获取不到就重新登录
                            if (GuoJiaToken == null) {
                                Map<String, Object> guoJiaMap = new HashMap<String, Object>();
                                guoJiaMap.put("s_id", InteGuoJiaUtil.getSid());
                                guoJiaMap.put("version", "1");
                                com.alibaba.fastjson.JSONObject bodyJson = new com.alibaba.fastjson.JSONObject();
                                //key
                                DESEncrypt desPlus2 = new DESEncrypt(InteGuoJiaConfig.DES_KEY);
                                //密码
                                bodyJson.put("account", InteGuoJiaConfig.ACCOUNT);
                                bodyJson.put("password", desPlus2.encrypt(InteGuoJiaConfig.PASSWORD));
                                guoJiaMap = InteGuoJiaUtil.login(guoJiaMap, bodyJson);
                                if (guoJiaMap.get("rlt_code") != null && guoJiaMap.get("rlt_code").toString().equals("HH0000")) {//HH0000 、成功
                                    //返回的token数据
                                    Map<String, Object> dataMap = (Map<String, Object>) guoJiaMap.get("data");
                                    GuoJiaToken = dataMap.get("access_token").toString();
                                    //token存到redis中
                                    redisUtils.set("GuoJiaToken", GuoJiaToken, Long.valueOf(dataMap.get("expires_second").toString()));
                                } else {
                                    return result.putFailed("token获取失败");
                                }
                            }
                            // 发送果加的门锁钥匙
                            Map<String, Object> headParams = new HashMap<String, Object>();
                            headParams.put("s_id", InteGuoJiaUtil.getSid());
                            headParams.put("version", "1");
                            headParams.put("access_token", GuoJiaToken);
                            JSONObject bodyJson = new JSONObject();
                            bodyJson.put("operate_pwd_auth", "N");//是否允许操作密码 Y 允许 N 不允许
                            bodyJson.put("set_custom_pwd", "N");//是否允许设置自定义密码 Y 允许 N 不允许智能是否允许设置自定义密码 Y 允许 N 不允许
                            bodyJson.put("lock_no", inteMap.get("Identifier"));//智能门锁的设备编号
                            bodyJson.put("mobile", params.get("TenMode"));//用户手机号
//                    bodyJson.put("auth_time_start",InteDeviceLockUtil.getTimeSign(map.get("StartTime").toString(),"yyyy-MM-dd HH:mm:ss"));//有效期开始时间
//                    bodyJson.put("auth_time_end",InteDeviceLockUtil.getTimeSign(DateUtils.format(DateUtils.addDateMonths( DateUtils.stringToDate(map.get("StartTime").toString(),"yyyy-MM-dd HH:mm:ss"),payCount))+InteDeviceLockConfig.LOCK_TIME,"yyyy-MM-dd HH:mm:ss"));//有效期结束时间
                            bodyJson.put("auth_time_start", InteDeviceLockUtil.getTimeSign(toDay,"yyyy-MM-dd HH:mm:ss"));
//                    bodyJson.put("auth_time_end",InteDeviceLockUtil.getTimeSign(map.get("EndTime").toString(),"yyyy-MM-dd HH:mm:ss"));//有效期结束时间
                            bodyJson.put("auth_time_end", InteDeviceLockUtil.getTimeSign(tomorrow,"yyyy-MM-dd HH:mm:ss"));
                            log.info("果加发钥匙:" + bodyJson);
                            Map<String, Object> guoJiaResult = InteGuoJiaUtil.lockAuth(headParams, bodyJson);
                            if (guoJiaResult.get("rlt_code") != null && guoJiaResult.get("rlt_code").toString().equals("HH0000")) {//HH0000 、成功
//                                InteMap.put("CodeId",inteMap.get("Identifier"));//钥匙的编码就存智能设备编码
//                                InteMap.put("Code",map.get("TenMode"));//果加的密码就存租客手机号
                            } else {
                                return result.putFailed(guoJiaResult.get("rlt_msg").toString());
                            }
                        }
                        //新增发送密钥的记录(只保存钥匙的记录)
//                        if (inteMap.get("Intelligent").toString().equals("2") || inteMap.get("Intelligent").toString().equals("3")){
//                            Integer smart=rdHousingSmartMapper.addRdHouSmart(InteMap);
//                            if(smart<=0){
//                                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                                return result.put("服务器繁忙");
//                            }
//                        }
                    }
                }

                params.put("IfArrive", "1");//0 未到达 1已到达
                params.put("by", ContextUtils.getUserId());//操作人
                params.put("term", "2");// 更新端 Update端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                params.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonUpdateParms(params);
                Integer count = rdWorderInfoMapper.updateWorderInfo(params);
                if (count != null && count == 1) {
                    result.putSuccess("操作成功");
                } else {
                    result.putFailed("服务器繁忙");
                }
            } catch (Exception e) {
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
        } finally {
            lock.unlock();
        }
        return result;
    }

    /**
     * 完成带看
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult updateWorderWan(Map<String, Object> params) {
        JsonResult result = new JsonResult();
        /**
         * 加锁操作
         */
        lock.lock();
        try {
            try {
                if (params.get("WoInfoId") == null || params.get("HouInfoId") == null || params.get("AskTime") == null
                        || params.get("TenId") == null) {
                    return result.putFailed("参数不正确");
                }
                Map<String, Object> askMap = new HashMap<String, Object>();
                //带看记录的数据
                askMap.putAll(params);
                //修改工单状态为带看完成
                params.put("State", "2");//工单状态（0 需带看 1带看中 2 带看完成 3 租客维护 4 换房申请）
                params.put("by", ContextUtils.getUserId());//操作人
                params.put("term", "2");// 更新端 Update端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                params.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonUpdateParms(params);
                //修改工单详表完成带看
                Integer count = rdWorderInfoMapper.updateWorderInfo(params);
                if (count > 0) {
                    //新增一条带看记录
                    askMap.put("by", ContextUtils.getUserId());//操作人
                    askMap.put("term", "2");// 更新端 Update端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                    askMap.put("fnc",
                            this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                    ParamsCommon.commonInsertParms(askMap);
                    askMap.put("SysUserId", ContextUtils.getUserId());//带看人编号（后台人员编号）
                    Integer askCount = rdTenantAskMapper.addTenantAsk(askMap);
                    if (askCount > 0) {
                        result.putSuccess("操作成功");
                    } else {
                        result.putFailed("服务器繁忙");
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    }
                } else {
                    result.putFailed("服务器繁忙");
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                }
            } catch (Exception e) {
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
        } finally {
            lock.unlock();
        }
        return result;
    }

    /**
     * 取消工单
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult updateWorderInfoState(Map<String, Object> params) {
        JsonResult result = new JsonResult();
        /**
         * 加锁操作
         */
        lock.lock();
        try {
            try {
                if (params.get("WoInfoId") == null) {
                    return result.putFailed("参数不正确");
                }
                params.put("State", "3");//0 需带看 1带看中 2 带看完成 3 租客维护 4 换房申请
                params.put("by", ContextUtils.getUserId());//操作人
                params.put("term", "2");// 更新端 Update端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                params.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonUpdateParms(params);
                Integer count = rdWorderInfoMapper.updateWorderInfo(params);
                if (count > 0) {
                    result.putSuccess("操作成功");
                } else {
                    result.putFailed("服务器繁忙");
                }
            } catch (Exception e) {
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
        } finally {
            lock.unlock();
        }
        return result;
    }

    /**
     * 转单到同事
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult updateTurn(Map<String, Object> params) {
        JsonResult result = new JsonResult();
        /**
         * 加锁操作
         */
        lock.lock();
        try {
            try {
                if (params.get("WoInfoId") == null) {
                    return result.put("参数不正确");
                }
                params.put("TurnStatus", "1");//转单状态（0 默认 1转单求助中 2 转单被接单）
                params.put("TurnCount", 1);//转单次数
                params.put("by", ContextUtils.getUserId());//操作人
                params.put("term", "2");// 更新端 Update端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                params.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonUpdateParms(params);
                params.put("TurnTime", params.get("updtm"));//转单时间 （记录点击转单的时间，用该时间比对是否两小时未操作）
                Integer count = rdWorderInfoMapper.updateWorderInfo(params);
                if (count != null && count == 1) {
                    result.putSuccess("操作成功");
                } else {
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    result.putFailed("服务器繁忙");
                }
            } catch (Exception e) {
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
        } finally {
            lock.unlock();
        }
        return result;
    }

    /**
     * 查询租赁顾问评价列表
     */
    public List<Map<String, Object>> getRdWorderEvaList(Map<String, Object> params) {
        //租赁顾问无法看到自己的评价
        String SysUserId = ContextUtils.getUserId();
        if (SysUserId != null && SysUserId.equals("18")) {
            params.put("SysUserId", SysUserId);
        }
        List<Map<String, Object>> getRdWorderEvaList = rdWorderInfoMapper.getRdWorderEvaList(params);

        if (getRdWorderEvaList.size() > 0) {
            //获取所有的后台用户资料
            JsonResult jsonResult = ZuulFeign.getAllUserIdAndName();
            List<Map<String, Object>> getAllUserIdAndName = (List<Map<String, Object>>) jsonResult.getResult();
            //合并
            getRdWorderEvaList = ListMapMergeUtil.ListMergeUtils(getRdWorderEvaList, getAllUserIdAndName, "userId");

            JsonResult jsonResult1 = TenantFeign.getTenantList();
            List<Map<String, Object>> getTenantList = (List<Map<String, Object>>) jsonResult1.getResult();
            //合并
            getRdWorderEvaList = ListMapMergeUtil.ListMergeUtils(getRdWorderEvaList, getTenantList, "TenId");

        }
        return getRdWorderEvaList;
    }

    /**
     * 查询租赁顾问评价列表总数
     */
    public Integer getRdWorderEvaListCount(Map<String, Object> params) {
        //租赁顾问无法看到自己的评价
        String SysUserId = ContextUtils.getUserId();
        if (SysUserId != null && SysUserId.equals("18")) {
            params.put("SysUserId", SysUserId);
        }
        return rdWorderInfoMapper.getRdWorderEvaListCount(params);
    }

    /**
     * 修改工单详表的带看时间
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult updateRdSeTime(Map<String, Object> params) {
        JsonResult result = new JsonResult();
        lock.lock();
        try {
            try {
                if (params.get("WoInfoId") == null || params.get("SeTime") == null) {
                    return result.putFailed("参数不正确");
                }
                params.put("by", ContextUtils.getUserId());//操作人
                params.put("term", "2");// 更新端 Update端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                params.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonUpdateParms(params);
                Integer count = rdWorderInfoMapper.updateRdSeTime(params);
                if (count > 0) {
                    result.putSuccess("操作成功");
                } else {
                    result.putFailed("服务器繁忙");
                }
            } catch (Exception e) {
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
        } finally {
            lock.unlock();
        }
        return result;
    }

    /**
     * 换房申请列表中创建工单、租客维护创建工单
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult addRdHouShelf(Map<String, Object> params) {
        JsonResult result = new JsonResult();
        /**
         * 加锁操作
         */
        lock.lock();
        try {
            try {
                if (params.get("WoId") == null || params.get("MakeUserName") == null || params.get("Remark") == null
                        || params.get("HouInfoId") == null) {
                    return result.putFailed("服务器繁忙");
                }
                String UUID = "";
                Map<String, Object> uuid = utilsMapper.getUUID(new HashMap<String, Object>() {{
                    put("uuid", "WoInfoId");
                    put("database", Constants.DATA_SOURCE_TCMKT);
                    put("surface", "tcmkt_worder_info");
                }});
                System.out.println("uuid:" + uuid);
                if (uuid != null && (!uuid.get("uuid").toString().equals(""))) {
                    int number = Integer.valueOf(uuid.get("uuid").toString());
                    UUID = ComUtils.getLocalTrmSeqNum("wi", number);
                } else {
                    UUID = ComUtils.getLocalTrmSeqNum("wi", 0);
                }
                params.put("WoInfoId", UUID);//工单详表编号
                params.put("OperId", ContextUtils.getUserId());//工单的接单人
                params.put("IfArrive", "1");//0 未到达 1已到达
                params.put("by", params.get("OperId"));//操作人
                params.put("IfSeeing", "0");//是否约看（0 约看 1不约看）
                params.put("IfArrive", "0");//是否到达（0 未到达 1已到达）
                params.put("IfState", "0");//是否废弃跟踪（如果放弃跟踪该状态为1） 0否 1是
                params.put("State", "0");//工单状态（0 需带看 1带看中 2 带看完成 3 租客维护 4 换房申请）
                params.put("term", "2");// 更新端 Update端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                params.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonUpdateParms(params);
                Integer count = rdWorderInfoMapper.addWorderInfo(params);
                if (count != null && count == 1) {
                    result.putSuccess("操作成功");
                } else {
                    result.putFailed("服务器繁忙");
                }
            } catch (Exception e) {
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
        } finally {
            lock.unlock();
        }
        return result;
    }

    /**
     * 租赁顾问拒绝转单
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult updateRdTurn(Map<String, Object> params) {
        JsonResult result = new JsonResult();
        /**
         * 加锁操作
         */
        lock.lock();
        try {
            try {
                if (params.get("WoInfoId") == null) {
                    return result.putFailed("参数不正确");
                }
                params.put("TurnCount", "0");//转单次数 （转单被接单该字段加一，如果该字段大于零，
                params.put("by", ContextUtils.getUserId());//操作人
                params.put("term", "2");// 更新端 Update端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                params.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonUpdateParms(params);
                Integer count = rdWorderInfoMapper.updateRdTurn(params);
                if (count != null && count == 1) {
                    result.putSuccess("操作成功");
                } else {
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    result.putFailed("服务器繁忙");
                }
            } catch (Exception e) {
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
        } finally {
            lock.unlock();
        }
        return result;
    }

    public static void main(String[] args) {

    }
}
